dom/serviceworkers/ServiceWorkerRegistrationInfo.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_serviceworkerregistrationinfo_h
   8 #define mozilla_dom_serviceworkerregistrationinfo_h
   9
  10 #include <functional>
  11
  12 #include "mozilla/dom/IPCNavigationPreloadState.h"
  13 #include "mozilla/dom/ServiceWorkerInfo.h"
  14 #include "mozilla/dom/ServiceWorkerRegistrationBinding.h"
  15 #include "mozilla/dom/ServiceWorkerRegistrationDescriptor.h"
  16 #include "nsProxyRelease.h"
  17 #include "nsTObserverArray.h"
  18
  19 namespace mozilla::dom {
  20
  21 class ServiceWorkerRegistrationListener;
  22
  23 class ServiceWorkerRegistrationInfo final
  24     : public nsIServiceWorkerRegistrationInfo {
  25   nsCOMPtr<nsIPrincipal> mPrincipal;
  26   ServiceWorkerRegistrationDescriptor mDescriptor;
  27   nsTArray<nsCOMPtr<nsIServiceWorkerRegistrationInfoListener>> mListeners;
  28   nsTObserverArray<ServiceWorkerRegistrationListener*> mInstanceList;
  29
  30   struct VersionEntry {
  31     const ServiceWorkerRegistrationDescriptor mDescriptor;
  32     TimeStamp mTimeStamp;
  33
  34     explicit VersionEntry(
  35         const ServiceWorkerRegistrationDescriptor& aDescriptor)
  36         : mDescriptor(aDescriptor), mTimeStamp(TimeStamp::Now()) {}
  37   };
  38   nsTArray<UniquePtr<VersionEntry>> mVersionList;
  39
  40   const nsID mAgentClusterId = nsID::GenerateUUID();
  41
  42   uint32_t mControlledClientsCounter;
  43   uint32_t mDelayMultiplier;
  44
  45   enum { NoUpdate, NeedTimeCheckAndUpdate, NeedUpdate } mUpdateState;
  46
  47   // Timestamp to track SWR's last update time
  48   PRTime mCreationTime;
  49   TimeStamp mCreationTimeStamp;
  50   // The time of update is 0, if SWR've never been updated yet.
  51   PRTime mLastUpdateTime;
  52
  53   RefPtr<ServiceWorkerInfo> mEvaluatingWorker;
  54   RefPtr<ServiceWorkerInfo> mActiveWorker;
  55   RefPtr<ServiceWorkerInfo> mWaitingWorker;
  56   RefPtr<ServiceWorkerInfo> mInstallingWorker;
  57
  58   virtual ~ServiceWorkerRegistrationInfo();
  59
  60   // When unregister() is called on a registration, it is removed from the
  61   // "scope to registration map" but not immediately "cleared" (i.e. its workers
  62   // terminated, updated to the redundant state, etc.) because it may still be
  63   // controlling clients. It is marked as unregistered and when all controlled
  64   // clients go away, cleared. This way we can tell if a registration
  65   // is unregistered by querying the object itself rather than incurring a table
  66   // lookup (in the case when the registrations are passed around as pointers).
  67   bool mUnregistered;
  68
  69   bool mCorrupt;
  70
  71   IPCNavigationPreloadState mNavigationPreloadState;
  72
  73  public:
  74   NS_DECL_ISUPPORTS
  75   NS_DECL_NSISERVICEWORKERREGISTRATIONINFO
  76
  77   using TryToActivateCallback = std::function<void()>;
  78
  79   ServiceWorkerRegistrationInfo(
  80       const nsACString& aScope, nsIPrincipal* aPrincipal,
  81       ServiceWorkerUpdateViaCache aUpdateViaCache,
  82       IPCNavigationPreloadState&& aNavigationPreloadState);
  83
  84   void AddInstance(ServiceWorkerRegistrationListener* aInstance,
  85                    const ServiceWorkerRegistrationDescriptor& aDescriptor);
  86
  87   void RemoveInstance(ServiceWorkerRegistrationListener* aInstance);
  88
  89   const nsCString& Scope() const;
  90
  91   nsIPrincipal* Principal() const;
  92
  93   bool IsUnregistered() const;
  94
  95   void SetUnregistered();
  96
  97   already_AddRefed<ServiceWorkerInfo> Newest() const {
  98     RefPtr<ServiceWorkerInfo> newest;
  99     if (mInstallingWorker) {
 100       newest = mInstallingWorker;
 101     } else if (mWaitingWorker) {
 102       newest = mWaitingWorker;
 103     } else {
 104       newest = mActiveWorker;
 105     }
 106
 107     return newest.forget();
 108   }
 109
 110   already_AddRefed<ServiceWorkerInfo> NewestIncludingEvaluating() const {
 111     if (mEvaluatingWorker) {
 112       RefPtr<ServiceWorkerInfo> newest = mEvaluatingWorker;
 113       return newest.forget();
 114     }
 115     return Newest();
 116   }
 117
 118   already_AddRefed<ServiceWorkerInfo> GetServiceWorkerInfoById(uint64_t aId);
 119
 120   void StartControllingClient() {
 121     ++mControlledClientsCounter;
 122     mDelayMultiplier = 0;
 123   }
 124
 125   void StopControllingClient() {
 126     MOZ_ASSERT(mControlledClientsCounter);
 127     --mControlledClientsCounter;
 128   }
 129
 130   bool IsControllingClients() const {
 131     return mActiveWorker && mControlledClientsCounter;
 132   }
 133
 134   // As a side effect, this nullifies
 135   // `m{Evaluating,Installing,Waiting,Active}Worker`s.
 136   void ShutdownWorkers();
 137
 138   void Clear();
 139
 140   void ClearAsCorrupt();
 141
 142   bool IsCorrupt() const;
 143
 144   void TryToActivateAsync(TryToActivateCallback&& aCallback = nullptr);
 145
 146   void TryToActivate(TryToActivateCallback&& aCallback);
 147
 148   void Activate();
 149
 150   void FinishActivate(bool aSuccess);
 151
 152   void RefreshLastUpdateCheckTime();
 153
 154   bool IsLastUpdateCheckTimeOverOneDay() const;
 155
 156   void MaybeScheduleTimeCheckAndUpdate();
 157
 158   void MaybeScheduleUpdate();
 159
 160   bool CheckAndClearIfUpdateNeeded();
 161
 162   ServiceWorkerInfo* GetEvaluating() const;
 163
 164   ServiceWorkerInfo* GetInstalling() const;
 165
 166   ServiceWorkerInfo* GetWaiting() const;
 167
 168   ServiceWorkerInfo* GetActive() const;
 169
 170   ServiceWorkerInfo* GetByDescriptor(
 171       const ServiceWorkerDescriptor& aDescriptor) const;
 172
 173   // Set the given worker as the evaluating service worker.  The worker
 174   // state is not changed.
 175   void SetEvaluating(ServiceWorkerInfo* aServiceWorker);
 176
 177   // Remove an existing evaluating worker, if present.  The worker will
 178   // be transitioned to the Redundant state.
 179   void ClearEvaluating();
 180
 181   // Remove an existing installing worker, if present.  The worker will
 182   // be transitioned to the Redundant state.
 183   void ClearInstalling();
 184
 185   // Transition the current evaluating worker to be the installing worker.  The
 186   // worker's state is update to Installing.
 187   void TransitionEvaluatingToInstalling();
 188
 189   // Transition the current installing worker to be the waiting worker.  The
 190   // worker's state is updated to Installed.
 191   void TransitionInstallingToWaiting();
 192
 193   // Override the current active worker.  This is used during browser
 194   // initialization to load persisted workers.  Its also used to propagate
 195   // active workers across child processes in e10s.  This second use will
 196   // go away once the ServiceWorkerManager moves to the parent process.
 197   // The worker is transitioned to the Activated state.
 198   void SetActive(ServiceWorkerInfo* aServiceWorker);
 199
 200   // Transition the current waiting worker to be the new active worker.  The
 201   // worker is updated to the Activating state.
 202   void TransitionWaitingToActive();
 203
 204   // Determine if the registration is actively performing work.
 205   bool IsIdle() const;
 206
 207   ServiceWorkerUpdateViaCache GetUpdateViaCache() const;
 208
 209   void SetUpdateViaCache(ServiceWorkerUpdateViaCache aUpdateViaCache);
 210
 211   int64_t GetLastUpdateTime() const;
 212
 213   void SetLastUpdateTime(const int64_t aTime);
 214
 215   const ServiceWorkerRegistrationDescriptor& Descriptor() const;
 216
 217   uint64_t Id() const;
 218
 219   uint64_t Version() const;
 220
 221   uint32_t GetUpdateDelay(const bool aWithMultiplier = true);
 222
 223   void FireUpdateFound();
 224
 225   void NotifyCleared();
 226
 227   void ClearWhenIdle();
 228
 229   const nsID& AgentClusterId() const;
 230
 231   void SetNavigationPreloadEnabled(const bool& aEnabled);
 232
 233   void SetNavigationPreloadHeader(const nsCString& aHeader);
 234
 235   IPCNavigationPreloadState GetNavigationPreloadState() const;
 236
 237  private:
 238   // Roughly equivalent to [[Update Registration State algorithm]]. Make sure
 239   // this is called *before* updating SW instances' state, otherwise they
 240   // may get CC-ed.
 241   void UpdateRegistrationState();
 242
 243   void UpdateRegistrationState(ServiceWorkerUpdateViaCache aUpdateViaCache);
 244
 245   // Used by devtools to track changes to the properties of
 246   // *nsIServiceWorkerRegistrationInfo*. Note, this doesn't necessarily need to
 247   // be in sync with the DOM registration objects, but it does need to be called
 248   // in the same task that changed |mInstallingWorker|, |mWaitingWorker| or
 249   // |mActiveWorker|.
 250   void NotifyChromeRegistrationListeners();
 251
 252   static uint64_t GetNextId();
 253
 254   static uint64_t GetNextVersion();
 255
 256   // `aFunc`'s argument will be a reference to
 257   // `m{Evaluating,Installing,Waiting,Active}Worker` (not to copy of them).
 258   // Additionally, a null check will be performed for each worker before each
 259   // call to `aFunc`, so `aFunc` will always get a reference to a non-null
 260   // pointer.
 261   void ForEachWorker(void (*aFunc)(RefPtr<ServiceWorkerInfo>&));
 262
 263   void CheckQuotaUsage();
 264 };
 265
 266 }  // namespace mozilla::dom
 267
 268 #endif  // mozilla_dom_serviceworkerregistrationinfo_h