dom/serviceworkers/ServiceWorkerRegistrationDescriptor.cpp

   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 #include "mozilla/dom/ServiceWorkerRegistrationDescriptor.h"
   8
   9 #include "mozilla/dom/IPCServiceWorkerRegistrationDescriptor.h"
  10 #include "mozilla/ipc/PBackgroundSharedTypes.h"
  11 #include "ServiceWorkerInfo.h"
  12
  13 namespace mozilla::dom {
  14
  15 using mozilla::ipc::PrincipalInfo;
  16 using mozilla::ipc::PrincipalInfoToPrincipal;
  17
  18 Maybe<IPCServiceWorkerDescriptor>
  19 ServiceWorkerRegistrationDescriptor::NewestInternal() const {
  20   Maybe<IPCServiceWorkerDescriptor> result;
  21   if (mData->installing().isSome()) {
  22     result.emplace(mData->installing().ref());
  23   } else if (mData->waiting().isSome()) {
  24     result.emplace(mData->waiting().ref());
  25   } else if (mData->active().isSome()) {
  26     result.emplace(mData->active().ref());
  27   }
  28   return result;
  29 }
  30
  31 ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(
  32     uint64_t aId, uint64_t aVersion, nsIPrincipal* aPrincipal,
  33     const nsACString& aScope, ServiceWorkerUpdateViaCache aUpdateViaCache)
  34     : mData(MakeUnique<IPCServiceWorkerRegistrationDescriptor>()) {
  35   MOZ_ALWAYS_SUCCEEDS(
  36       PrincipalToPrincipalInfo(aPrincipal, &mData->principalInfo()));
  37
  38   mData->id() = aId;
  39   mData->version() = aVersion;
  40   mData->scope() = aScope;
  41   mData->updateViaCache() = aUpdateViaCache;
  42   mData->installing() = Nothing();
  43   mData->waiting() = Nothing();
  44   mData->active() = Nothing();
  45 }
  46
  47 ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(
  48     uint64_t aId, uint64_t aVersion,
  49     const mozilla::ipc::PrincipalInfo& aPrincipalInfo, const nsACString& aScope,
  50     ServiceWorkerUpdateViaCache aUpdateViaCache)
  51     : mData(MakeUnique<IPCServiceWorkerRegistrationDescriptor>(
  52           aId, aVersion, aPrincipalInfo, nsCString(aScope), aUpdateViaCache,
  53           Nothing(), Nothing(), Nothing())) {}
  54
  55 ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(
  56     const IPCServiceWorkerRegistrationDescriptor& aDescriptor)
  57     : mData(MakeUnique<IPCServiceWorkerRegistrationDescriptor>(aDescriptor)) {
  58   MOZ_DIAGNOSTIC_ASSERT(IsValid());
  59 }
  60
  61 ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(
  62     const ServiceWorkerRegistrationDescriptor& aRight) {
  63   // UniquePtr doesn't have a default copy constructor, so we can't rely
  64   // on default copy construction.  Use the assignment operator to
  65   // minimize duplication.
  66   operator=(aRight);
  67 }
  68
  69 ServiceWorkerRegistrationDescriptor&
  70 ServiceWorkerRegistrationDescriptor::operator=(
  71     const ServiceWorkerRegistrationDescriptor& aRight) {
  72   if (this == &aRight) {
  73     return *this;
  74   }
  75   mData.reset();
  76   mData = MakeUnique<IPCServiceWorkerRegistrationDescriptor>(*aRight.mData);
  77   MOZ_DIAGNOSTIC_ASSERT(IsValid());
  78   return *this;
  79 }
  80
  81 ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(
  82     ServiceWorkerRegistrationDescriptor&& aRight)
  83     : mData(std::move(aRight.mData)) {
  84   MOZ_DIAGNOSTIC_ASSERT(IsValid());
  85 }
  86
  87 ServiceWorkerRegistrationDescriptor&
  88 ServiceWorkerRegistrationDescriptor::operator=(
  89     ServiceWorkerRegistrationDescriptor&& aRight) {
  90   mData.reset();
  91   mData = std::move(aRight.mData);
  92   MOZ_DIAGNOSTIC_ASSERT(IsValid());
  93   return *this;
  94 }
  95
  96 ServiceWorkerRegistrationDescriptor::~ServiceWorkerRegistrationDescriptor() {
  97   // Non-default destructor to avoid exposing the IPC type in the header.
  98 }
  99
 100 bool ServiceWorkerRegistrationDescriptor::operator==(
 101     const ServiceWorkerRegistrationDescriptor& aRight) const {
 102   return *mData == *aRight.mData;
 103 }
 104
 105 uint64_t ServiceWorkerRegistrationDescriptor::Id() const { return mData->id(); }
 106
 107 uint64_t ServiceWorkerRegistrationDescriptor::Version() const {
 108   return mData->version();
 109 }
 110
 111 ServiceWorkerUpdateViaCache
 112 ServiceWorkerRegistrationDescriptor::UpdateViaCache() const {
 113   return mData->updateViaCache();
 114 }
 115
 116 const mozilla::ipc::PrincipalInfo&
 117 ServiceWorkerRegistrationDescriptor::PrincipalInfo() const {
 118   return mData->principalInfo();
 119 }
 120
 121 Result<nsCOMPtr<nsIPrincipal>, nsresult>
 122 ServiceWorkerRegistrationDescriptor::GetPrincipal() const {
 123   AssertIsOnMainThread();
 124   return PrincipalInfoToPrincipal(mData->principalInfo());
 125 }
 126
 127 const nsCString& ServiceWorkerRegistrationDescriptor::Scope() const {
 128   return mData->scope();
 129 }
 130
 131 Maybe<ServiceWorkerDescriptor>
 132 ServiceWorkerRegistrationDescriptor::GetInstalling() const {
 133   Maybe<ServiceWorkerDescriptor> result;
 134
 135   if (mData->installing().isSome()) {
 136     result.emplace(ServiceWorkerDescriptor(mData->installing().ref()));
 137   }
 138
 139   return result;
 140 }
 141
 142 Maybe<ServiceWorkerDescriptor> ServiceWorkerRegistrationDescriptor::GetWaiting()
 143     const {
 144   Maybe<ServiceWorkerDescriptor> result;
 145
 146   if (mData->waiting().isSome()) {
 147     result.emplace(ServiceWorkerDescriptor(mData->waiting().ref()));
 148   }
 149
 150   return result;
 151 }
 152
 153 Maybe<ServiceWorkerDescriptor> ServiceWorkerRegistrationDescriptor::GetActive()
 154     const {
 155   Maybe<ServiceWorkerDescriptor> result;
 156
 157   if (mData->active().isSome()) {
 158     result.emplace(ServiceWorkerDescriptor(mData->active().ref()));
 159   }
 160
 161   return result;
 162 }
 163
 164 Maybe<ServiceWorkerDescriptor> ServiceWorkerRegistrationDescriptor::Newest()
 165     const {
 166   Maybe<ServiceWorkerDescriptor> result;
 167   Maybe<IPCServiceWorkerDescriptor> newest(NewestInternal());
 168   if (newest.isSome()) {
 169     result.emplace(ServiceWorkerDescriptor(newest.ref()));
 170   }
 171   return result;
 172 }
 173
 174 bool ServiceWorkerRegistrationDescriptor::HasWorker(
 175     const ServiceWorkerDescriptor& aDescriptor) const {
 176   Maybe<ServiceWorkerDescriptor> installing = GetInstalling();
 177   Maybe<ServiceWorkerDescriptor> waiting = GetWaiting();
 178   Maybe<ServiceWorkerDescriptor> active = GetActive();
 179   return (installing.isSome() && installing.ref().Matches(aDescriptor)) ||
 180          (waiting.isSome() && waiting.ref().Matches(aDescriptor)) ||
 181          (active.isSome() && active.ref().Matches(aDescriptor));
 182 }
 183
 184 namespace {
 185
 186 bool IsValidWorker(
 187     const Maybe<IPCServiceWorkerDescriptor>& aWorker, const nsACString& aScope,
 188     const mozilla::ipc::ContentPrincipalInfo& aContentPrincipal) {
 189   if (aWorker.isNothing()) {
 190     return true;
 191   }
 192
 193   auto& worker = aWorker.ref();
 194   if (worker.scope() != aScope) {
 195     return false;
 196   }
 197
 198   auto& principalInfo = worker.principalInfo();
 199   if (principalInfo.type() !=
 200       mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) {
 201     return false;
 202   }
 203
 204   auto& contentPrincipal = principalInfo.get_ContentPrincipalInfo();
 205   if (contentPrincipal.originNoSuffix() != aContentPrincipal.originNoSuffix() ||
 206       contentPrincipal.attrs() != aContentPrincipal.attrs()) {
 207     return false;
 208   }
 209
 210   return true;
 211 }
 212
 213 }  // anonymous namespace
 214
 215 bool ServiceWorkerRegistrationDescriptor::IsValid() const {
 216   auto& principalInfo = PrincipalInfo();
 217   if (principalInfo.type() !=
 218       mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) {
 219     return false;
 220   }
 221
 222   auto& contentPrincipal = principalInfo.get_ContentPrincipalInfo();
 223   if (!IsValidWorker(mData->installing(), Scope(), contentPrincipal) ||
 224       !IsValidWorker(mData->waiting(), Scope(), contentPrincipal) ||
 225       !IsValidWorker(mData->active(), Scope(), contentPrincipal)) {
 226     return false;
 227   }
 228
 229   return true;
 230 }
 231
 232 void ServiceWorkerRegistrationDescriptor::SetUpdateViaCache(
 233     ServiceWorkerUpdateViaCache aUpdateViaCache) {
 234   mData->updateViaCache() = aUpdateViaCache;
 235 }
 236
 237 void ServiceWorkerRegistrationDescriptor::SetWorkers(
 238     ServiceWorkerInfo* aInstalling, ServiceWorkerInfo* aWaiting,
 239     ServiceWorkerInfo* aActive) {
 240   if (aInstalling) {
 241     aInstalling->SetRegistrationVersion(Version());
 242     mData->installing() = Some(aInstalling->Descriptor().ToIPC());
 243   } else {
 244     mData->installing() = Nothing();
 245   }
 246
 247   if (aWaiting) {
 248     aWaiting->SetRegistrationVersion(Version());
 249     mData->waiting() = Some(aWaiting->Descriptor().ToIPC());
 250   } else {
 251     mData->waiting() = Nothing();
 252   }
 253
 254   if (aActive) {
 255     aActive->SetRegistrationVersion(Version());
 256     mData->active() = Some(aActive->Descriptor().ToIPC());
 257   } else {
 258     mData->active() = Nothing();
 259   }
 260
 261   MOZ_DIAGNOSTIC_ASSERT(IsValid());
 262 }
 263
 264 void ServiceWorkerRegistrationDescriptor::SetVersion(uint64_t aVersion) {
 265   MOZ_DIAGNOSTIC_ASSERT(aVersion > mData->version());
 266   mData->version() = aVersion;
 267 }
 268
 269 const IPCServiceWorkerRegistrationDescriptor&
 270 ServiceWorkerRegistrationDescriptor::ToIPC() const {
 271   return *mData;
 272 }
 273
 274 }  // namespace mozilla::dom